﻿using System;
using System.Runtime.InteropServices;
using ArgusLib.FFmpeg.avutil;
using uint64_t = System.UInt64;
using int64_t = System.Int64;

namespace ArgusLib.FFmpeg.avcodec.Interop
{
	/// <summary>
	/// main external API structure.
	/// New fields can be added to the end with minor version bumps.
	/// Removal, reordering and changes to existing fields require a major
	/// version bump.
	/// Please use AVOptions (av_opt/// / av_set/get///()) to access these fields from user
	/// applications.
	/// sizeof(AVCodecContext) must not be used outside libav///.
	/// </summary>
	[StructLayout(LayoutKind.Sequential)]
	public class AVCodecContextNative
	{
		#region Fields
		/// <summary>
		/// information on struct for av_log
		/// - set by avcodec_alloc_context3
		/// </summary>
		internal IntPtr av_class;
		internal int log_level_offset;

		internal AVMediaType codec_type; //// see AVMEDIA_TYPE_xxx /// </summary>
		internal IntPtr codec;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)]
		internal string codec_name;

		internal AVCodecID codec_id; //// see AV_CODEC_ID_xxx /// </summary>

		/// <summary>
		/// fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
		/// This is used to work around some encoder bugs.
		/// A demuxer should set this to what is stored in the field used to identify the codec.
		/// If there are multiple such fields in a container then the demuxer should choose the one
		/// which maximizes the information about the used codec.
		/// If the codec tag field in a container is larger than 32 bits then the demuxer should
		/// remap the longer ID to 32 bits with a table or other structure. Alternatively a new
		/// extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
		/// first.
		/// - encoding: Set by user, if not then the default based on codec_id will be used.
		/// - decoding: Set by user, will be converted to uppercase by libavcodec during init.
		/// </summary>
		internal uint codec_tag;

		/// <summary>
		/// fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
		/// This is used to work around some encoder bugs.
		/// - encoding: unused
		/// - decoding: Set by user, will be converted to uppercase by libavcodec during init.
		/// </summary>
		internal uint stream_codec_tag;

		internal IntPtr priv_data;

		/// <summary>
		/// Private context used for internal data.
		///
		/// Unlike priv_data, this is not codec-specific. It is used in general
		/// libavcodec functions.
		/// </summary>
		internal IntPtr internal_codec;

		/// <summary>
		/// Private data of the user, can be used to carry app specific stuff.
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal IntPtr opaque;

		/// <summary>
		/// the average bitrate
		/// - encoding: Set by user; unused for constant quantizer encoding.
		/// - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
		/// </summary>
		internal int bit_rate;

		/// <summary>
		/// number of bits the bitstream is allowed to diverge from the reference.
		///           the reference can be CBR (for CBR pass1) or VBR (for pass2)
		/// - encoding: Set by user; unused for constant quantizer encoding.
		/// - decoding: unused
		/// </summary>
		internal int bit_rate_tolerance;

		/// <summary>
		/// Global quality for codecs which cannot change it per frame.
		/// This should be proportional to MPEG-1/2/4 qscale.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int global_quality;

		/// <summary>
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int compression_level;
//#define FF_COMPRESSION_DEFAULT -1

		/// <summary>
		/// CODEC_FLAG_///.
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal int flags;

		/// <summary>
		/// CODEC_FLAG2_///
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal int flags2;

		/// <summary>
		/// some codecs need / can use extradata like Huffman tables.
		/// mjpeg: Huffman tables
		/// rv10: additional flags
		/// mpeg4: global headers (they can be in the bitstream or here)
		/// The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger
		/// than extradata_size to avoid problems if it is read with the bitstream reader.
		/// The bytewise contents of extradata must not depend on the architecture or CPU endianness.
		/// - encoding: Set/allocated/freed by libavcodec.
		/// - decoding: Set/allocated/freed by user.
		/// </summary>
		internal IntPtr extradata;
		internal int extradata_size;

		/// <summary>
		/// This is the fundamental unit of time (in seconds) in terms
		/// of which frame timestamps are represented. For fixed-fps content,
		/// timebase should be 1/framerate and timestamp increments should be
		/// identically 1.
		/// - encoding: MUST be set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal AVRational time_base;

		/// <summary>
		/// For some codecs, the time base is closer to the field rate than the frame rate.
		/// Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
		/// if no telecine is used ...
		///
		/// Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
		/// </summary>
		internal int ticks_per_frame;

		/// <summary>
		/// Codec delay.
		///
		/// Encoding: Number of frames delay there will be from the encoder input to
		///           the decoder output. (we assume the decoder matches the spec)
		/// Decoding: Number of frames delay in addition to what a standard decoder
		///           as specified in the spec would produce.
		///
		/// Video:
		///   Number of frames the decoded output will be delayed relative to the
		///   encoded input.
		///
		/// Audio:
		///   For encoding, this is the number of "priming" samples added to the
		///   beginning of the stream. The decoded output will be delayed by this
		///   many samples relative to the input to the encoder. Note that this
		///   field is purely informational and does not directly affect the pts
		///   output by the encoder, which should always be based on the actual
		///   presentation time, including any delay.
		///   For decoding, this is the number of samples the decoder needs to
		///   output before the decoder's output is valid. When seeking, you should
		///   start decoding this many samples prior to your desired seek point.
		///
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal int delay;


		//// video only /// </summary>
		/// <summary>
		/// picture width / height.
		/// - encoding: MUST be set by user.
		/// - decoding: May be set by the user before opening the decoder if known e.g.
		///             from the container. Some decoders will require the dimensions
		///             to be set by the caller. During decoding, the decoder may
		///             overwrite those values as required.
		/// </summary>
		internal int width, height;

		/// <summary>
		/// Bitstream width / height, may be different from width/height e.g. when
		/// the decoded frame is cropped before being output or lowres is enabled.
		/// - encoding: unused
		/// - decoding: May be set by the user before opening the decoder if known
		///             e.g. from the container. During decoding, the decoder may
		///             overwrite those values as required.
		/// </summary>
		internal int coded_width, coded_height;

//#define FF_ASPECT_EXTENDED 15

		/// <summary>
		/// the number of pictures in a group of pictures, or 0 for intra_only
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int gop_size;

		/// <summary>
		/// Pixel format, see AV_PIX_FMT_xxx.
		/// May be set by the demuxer if known from headers.
		/// May be overridden by the decoder if it knows better.
		/// - encoding: Set by user.
		/// - decoding: Set by user if known, overridden by libavcodec if known
		/// </summary>
		internal AVPixelFormat pix_fmt;

		/// <summary>
		/// Motion estimation algorithm used for video coding.
		/// 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),
		/// 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific]
		/// - encoding: MUST be set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_method;

		/// <summary>
		/// If non NULL, 'draw_horiz_band' is called by the libavcodec
		/// decoder to draw a horizontal band. It improves cache usage. Not
		/// all codecs can do that. You must check the codec capabilities
		/// beforehand.
		/// When multithreading is used, it may be called from multiple threads
		/// at the same time; threads might draw different parts of the same AVFrame,
		/// or multiple AVFrames, and there is no guarantee that slices will be drawn
		/// in order.
		/// The function is also used by hardware acceleration APIs.
		/// It is called at least once during frame decoding to pass
		/// the data needed for hardware render.
		/// In that mode instead of pixel data, AVFrame points to
		/// a structure specific to the acceleration API. The application
		/// reads the structure and can change some fields to indicate progress
		/// or mark state.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// @param height the height of the slice
		/// @param y the y position of the slice
		/// @param type 1->top field, 2->bottom field, 3->frame
		/// @param offset offset into the AVFrame.data from which the slice should be read
		/// </summary>
		internal IntPtr draw_horiz_band;

		/// <summary>
		/// callback to negotiate the pixelFormat
		/// @param fmt is the list of formats which are supported by the codec,
		/// it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
		/// The first is always the native one.
		/// @return the chosen format
		/// - encoding: unused
		/// - decoding: Set by user, if not set the native format will be chosen.
		/// </summary>
		internal IntPtr get_format;

		/// <summary>
		/// maximum number of B-frames between non-B-frames
		/// Note: The output will be delayed by max_b_frames+1 relative to the input.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int max_b_frames;

		/// <summary>
		/// qscale factor between IP and B-frames
		/// If > 0 then the last P-frame quantizer will be used (q= lastp_q///factor+offset).
		/// If < 0 then normal ratecontrol will be done (q= -normal_q///factor+offset).
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float b_quant_factor;

		/// <summary> obsolete FIXME remove /// </summary>
		internal int rc_strategy;
//#define FF_RC_STRATEGY_XVID 1

		internal int b_frame_strategy;

		/// <summary>
		/// qscale offset between IP and B-frames
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float b_quant_offset;

		/// <summary>
		/// Size of the frame reordering buffer in the decoder.
		/// For MPEG-2 it is 1 IPB or 0 low delay IP.
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal int has_b_frames;

		/// <summary>
		/// 0-> h263 quant 1-> mpeg quant
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mpeg_quant;

		/// <summary>
		/// qscale factor between P and I-frames
		/// If > 0 then the last p frame quantizer will be used (q= lastp_q///factor+offset).
		/// If < 0 then normal ratecontrol will be done (q= -normal_q///factor+offset).
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float i_quant_factor;

		/// <summary>
		/// qscale offset between P and I-frames
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float i_quant_offset;

		/// <summary>
		/// luminance masking (0-> disabled)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float lumi_masking;

		/// <summary>
		/// temporary complexity masking (0-> disabled)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float temporal_cplx_masking;

		/// <summary>
		/// spatial complexity masking (0-> disabled)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float spatial_cplx_masking;

		/// <summary>
		/// p block masking (0-> disabled)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float p_masking;

		/// <summary>
		/// darkness masking (0-> disabled)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float dark_masking;

		/// <summary>
		/// slice count
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by user (or 0).
		/// </summary>
		internal int slice_count;
		/// <summary>
		/// prediction method (needed for huffyuv)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal FF_PRED prediction_method;

		/// <summary>
		/// slice offsets in the frame in bytes
		/// - encoding: Set/allocated by libavcodec.
		/// - decoding: Set/allocated by user (or NULL).
		/// </summary>
		internal IntPtr slice_offset;

		/// <summary>
		/// sample aspect ratio (0 if unknown)
		/// That is the width of a pixel divided by the height of the pixel.
		/// Numerator and denominator must be relatively prime and smaller than 256 for some video standards.
		/// - encoding: Set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal AVRational sample_aspect_ratio;

		/// <summary>
		/// motion estimation comparison function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_cmp;
		/// <summary>
		/// subpixel motion estimation comparison function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_sub_cmp;
		/// <summary>
		/// macroblock comparison function (not supported yet)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mb_cmp;
		/// <summary>
		/// interlaced DCT comparison function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal FF_CMP ildct_cmp;

		/// <summary>
		/// ME diamond size & shape
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int dia_size;

		/// <summary>
		/// amount of previous MV predictors (2a+1 x 2a+1 square)
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int last_predictor_count;

		/// <summary>
		/// prepass for motion estimation
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int pre_me;

		/// <summary>
		/// motion estimation prepass comparison function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_pre_cmp;

		/// <summary>
		/// ME prepass diamond size & shape
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int pre_dia_size;

		/// <summary>
		/// subpel ME quality
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_subpel_quality;

		/// <summary>
		/// DTG active format information (additional aspect ratio
		/// information only used in DVB MPEG-2 transport streams)
		/// 0 if not set.
		///
		/// - encoding: unused
		/// - decoding: Set by decoder.
		/// </summary>
		internal FF_DTG dtg_active_format;

		/// <summary>
		/// maximum motion estimation search range in subpel units
		/// If 0 then no limit.
		///
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_range;

		/// <summary>
		/// intra quantizer bias
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int intra_quant_bias;
//#define FF_DEFAULT_QUANT_BIAS 999999

		/// <summary>
		/// inter quantizer bias
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int inter_quant_bias;

		/// <summary>
		/// slice flags
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal SLICE_FLAG slice_flags;

		/// <summary>
		/// XVideo Motion Acceleration
		/// - encoding: forbidden
		/// - decoding: set by decoder
		/// </summary>
		internal int xvmc_acceleration;

		/// <summary>
		/// macroblock decision mode
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal FF_MB mb_decision;

		/// <summary>
		/// custom intra quantization matrix
		/// - encoding: Set by user, can be NULL.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal IntPtr intra_matrix;

		/// <summary>
		/// custom inter quantization matrix
		/// - encoding: Set by user, can be NULL.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal IntPtr inter_matrix;

		/// <summary>
		/// scene change detection threshold
		/// 0 is default, larger means fewer detected scene changes.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int scenechange_threshold;

		/// <summary>
		/// noise reduction strength
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int noise_reduction;

		/// <summary>
		/// Motion estimation threshold below which no motion estimation is
		/// performed, but instead the user specified motion vectors are used.
		///
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_threshold;

		/// <summary>
		/// Macroblock threshold below which the user specified macroblock types will be used.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mb_threshold;

		/// <summary>
		/// precision of the intra DC coefficient - 8
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int intra_dc_precision;

		/// <summary>
		/// Number of macroblock rows at the top which are skipped.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal int skip_top;

		/// <summary>
		/// Number of macroblock rows at the bottom which are skipped.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal int skip_bottom;

		/// <summary>
		/// Border processing masking, raises the quantizer for mbs on the borders
		/// of the picture.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float border_masking;

		/// <summary>
		/// minimum MB lagrange multipler
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mb_lmin;

		/// <summary>
		/// maximum MB lagrange multipler
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mb_lmax;

		/// <summary>
		///
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int me_penalty_compensation;

		/// <summary>
		///
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int bidir_refine;

		/// <summary>
		///
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int brd_scale;

		/// <summary>
		/// minimum GOP size
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int keyint_min;

		/// <summary>
		/// number of reference frames
		/// - encoding: Set by user.
		/// - decoding: Set by lavc.
		/// </summary>
		internal int refs;

		/// <summary>
		/// chroma qp offset from luma
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int chromaoffset;

		/// <summary>
		/// Multiplied by qscale for each frame and added to scene_change_score.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int scenechange_factor;

		/// <summary>
		///
		/// Note: Value depends upon the compare function used for fullpel ME.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int mv0_threshold;

		/// <summary>
		/// Adjust sensitivity of b_frame_strategy 1.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int b_sensitivity;

		/// <summary>
		/// Chromaticity coordinates of the source primaries.
		/// - encoding: Set by user
		/// - decoding: Set by libavcodec
		/// </summary>
		internal AVColorPrimaries color_primaries;

		/// <summary>
		/// Color Transfer Characteristic.
		/// - encoding: Set by user
		/// - decoding: Set by libavcodec
		/// </summary>
		internal AVColorTransferCharacteristic color_trc;

		/// <summary>
		/// YUV colorspace type.
		/// - encoding: Set by user
		/// - decoding: Set by libavcodec
		/// </summary>
		internal AVColorSpace colorspace;

		/// <summary>
		/// MPEG vs JPEG YUV range.
		/// - encoding: Set by user
		/// - decoding: Set by libavcodec
		/// </summary>
		internal AVColorRange color_range;

		/// <summary>
		/// This defines the location of chroma samples.
		/// - encoding: Set by user
		/// - decoding: Set by libavcodec
		/// </summary>
		internal AVChromaLocation chroma_sample_location;

		/// <summary>
		/// Number of slices.
		/// Indicates number of picture subdivisions. Used for parallelized
		/// decoding.
		/// - encoding: Set by user
		/// - decoding: unused
		/// </summary>
		internal int slices;

		/// <summary> Field order
		/// - encoding: set by libavcodec
		/// - decoding: Set by user.
		/// </summary>
		internal AVFieldOrder field_order;

		//// audio only /// </summary>
		internal int sample_rate; ///< samples per second
		internal int channels;    ///< number of audio channels

		/// <summary>
		/// audio sample format
		/// - encoding: Set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal AVSampleFormat sample_fmt;  ///< sample format

		//// The following data should not be initialized. /// </summary>
		/// <summary>
		/// Number of samples per channel in an audio frame.
		///
		/// - encoding: set by libavcodec in avcodec_open2(). Each submitted frame
		///   except the last must contain exactly frame_size samples per channel.
		///   May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
		///   frame size is not restricted.
		/// - decoding: may be set by some decoders to indicate constant frame size
		/// </summary>
		internal int frame_size;

		/// <summary>
		/// Frame counter, set by libavcodec.
		///
		/// - decoding: total number of frames returned from the decoder so far.
		/// - encoding: total number of frames passed to the encoder so far.
		///
		///   @note the counter is not incremented if encoding/decoding resulted in
		///   an error.
		/// </summary>
		internal int frame_number;

		/// <summary>
		/// number of bytes per packet if constant and known or 0
		/// Used by some WAV based audio codecs.
		/// </summary>
		internal int block_align;

		/// <summary>
		/// Audio cutoff bandwidth (0 means "automatic")
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int cutoff;

		#if FF_API_REQUEST_CHANNELS
		/// <summary>
		/// Decoder should decode to this many channels if it can (0 for default)
		/// - encoding: unused
		/// - decoding: Set by user.
		/// @deprecated Deprecated in favor of request_channel_layout.
		/// </summary>
		attribute_deprecated int request_channels;
		#endif

		/// <summary>
		/// Audio channel layout.
		/// - encoding: set by user.
		/// - decoding: set by user, may be overwritten by libavcodec.
		/// </summary>
		internal uint64_t channel_layout;

		/// <summary>
		/// Request decoder to use this channel layout if it can (0 for default)
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal uint64_t request_channel_layout;

		/// <summary>
		/// Type of service that the audio stream conveys.
		/// - encoding: Set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal AVAudioServiceType audio_service_type;

		/// <summary>
		/// desired sample format
		/// - encoding: Not used.
		/// - decoding: Set by user.
		/// Decoder will decode to this format if it can.
		/// </summary>
		internal AVSampleFormat request_sample_fmt;

		#if FF_API_GET_BUFFER
		/// <summary>
		/// Called at the beginning of each frame to get a buffer for it.
		///
		/// The function will set AVFrame.data[], AVFrame.linesize[].
		/// AVFrame.extended_data[] must also be set, but it should be the same as
		/// AVFrame.data[] except for planar audio with more channels than can fit
		/// in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as
		/// many data pointers as it can hold.
		///
		/// if CODEC_CAP_DR1 is not set then get_buffer() must call
		/// avcodec_default_get_buffer() instead of providing buffers allocated by
		/// some other means.
		///
		/// AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't
		/// need it. avcodec_default_get_buffer() aligns the output buffer properly,
		/// but if get_buffer() is overridden then alignment considerations should
		/// be taken into account.
		///
		/// @see avcodec_default_get_buffer()
		///
		/// Video:
		///
		/// If pic.reference is set then the frame will be read later by libavcodec.
		/// avcodec_align_dimensions2() should be used to find the required width and
		/// height, as they normally need to be rounded up to the next multiple of 16.
		///
		/// If frame multithreading is used and thread_safe_callbacks is set,
		/// it may be called from a different thread, but not from more than one at
		/// once. Does not need to be reentrant.
		///
		/// @see release_buffer(), reget_buffer()
		/// @see avcodec_align_dimensions2()
		///
		/// Audio:
		///
		/// Decoders request a buffer of a particular size by setting
		/// AVFrame.nb_samples prior to calling get_buffer(). The decoder may,
		/// however, utilize only part of the buffer by setting AVFrame.nb_samples
		/// to a smaller value in the output frame.
		///
		/// Decoders cannot use the buffer after returning from
		/// avcodec_decode_audio4(), so they will not call release_buffer(), as it
		/// is assumed to be released immediately upon return. In some rare cases,
		/// a decoder may need to call get_buffer() more than once in a single
		/// call to avcodec_decode_audio4(). In that case, when get_buffer() is
		/// called again after it has already been called once, the previously
		/// acquired buffer is assumed to be released at that time and may not be
		/// reused by the decoder.
		///
		/// As a convenience, av_samples_get_buffer_size() and
		/// av_samples_fill_arrays() in libavutil may be used by custom get_buffer()
		/// functions to find the required data size and to fill data pointers and
		/// linesize. In AVFrame.linesize, only linesize[0] may be set for audio
		/// since all planes must be the same size.
		///
		/// @see av_samples_get_buffer_size(), av_samples_fill_arrays()
		///
		/// - encoding: unused
		/// - decoding: Set by libavcodec, user can override.
		///
		/// @deprecated use get_buffer2()
		/// </summary>
		attribute_deprecated
		int (///get_buffer)(struct AVCodecContext ///c, AVFrame ///pic);

		/// <summary>
		/// Called to release buffers which were allocated with get_buffer.
		/// A released buffer can be reused in get_buffer().
		/// pic.data[///] must be set to NULL.
		/// May be called from a different thread if frame multithreading is used,
		/// but not by more than one thread at once, so does not need to be reentrant.
		/// - encoding: unused
		/// - decoding: Set by libavcodec, user can override.
		///
		/// @deprecated custom freeing callbacks should be set from get_buffer2()
		/// </summary>
		attribute_deprecated
		void (///release_buffer)(struct AVCodecContext ///c, AVFrame ///pic);

		/// <summary>
		/// Called at the beginning of a frame to get cr buffer for it.
		/// Buffer type (size, hints) must be the same. libavcodec won't check it.
		/// libavcodec will pass previous buffer in pic, function should return
		/// same buffer or new buffer with old frame "painted" into it.
		/// If pic.data[0] == NULL must behave like get_buffer().
		/// if CODEC_CAP_DR1 is not set then reget_buffer() must call
		/// avcodec_default_reget_buffer() instead of providing buffers allocated by
		/// some other means.
		/// - encoding: unused
		/// - decoding: Set by libavcodec, user can override.
		/// </summary>
		attribute_deprecated
		int (///reget_buffer)(struct AVCodecContext ///c, AVFrame ///pic);
		#endif

		/// <summary>
		/// This callback is called at the beginning of each frame to get data
		/// buffer(s) for it. There may be one contiguous buffer for all the data or
		/// there may be a buffer per each data plane or anything in between. What
		/// this means is, you may set however many entries in buf[] you feel necessary.
		/// Each buffer must be reference-counted using the AVBuffer API (see description
		/// of buf[] below).
		///
		/// The following fields will be set in the frame before this callback is
		/// called:
		/// - format
		/// - width, height (video only)
		/// - sample_rate, channel_layout, nb_samples (audio only)
		/// Their values may differ from the corresponding values in
		/// AVCodecContext. This callback must use the frame values, not the codec
		/// context values, to calculate the required buffer size.
		///
		/// This callback must fill the following fields in the frame:
		/// - data[]
		/// - linesize[]
		/// - extended_data:
		///   /// if the data is planar audio with more than 8 channels, then this
		///     callback must allocate and fill extended_data to contain all pointers
		///     to all data planes. data[] must hold as many pointers as it can.
		///     extended_data must be allocated with av_malloc() and will be freed in
		///     av_frame_unref().
		///   /// otherwise exended_data must point to data
		/// - buf[] must contain one or more pointers to AVBufferRef structures. Each of
		///   the frame's data and extended_data pointers must be contained in these. That
		///   is, one AVBufferRef for each allocated chunk of memory, not necessarily one
		///   AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(),
		///   and av_buffer_ref().
		/// - extended_buf and nb_extended_buf must be allocated with av_malloc() by
		///   this callback and filled with the extra buffers if there are more
		///   buffers than buf[] can hold. extended_buf will be freed in
		///   av_frame_unref().
		///
		/// If CODEC_CAP_DR1 is not set then get_buffer2() must call
		/// avcodec_default_get_buffer2() instead of providing buffers allocated by
		/// some other means.
		///
		/// Each data plane must be aligned to the maximum required by the target
		/// CPU.
		///
		/// @see avcodec_default_get_buffer2()
		///
		/// Video:
		///
		/// If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
		/// (read and/or written to if it is writable) later by libavcodec.
		///
		/// If CODEC_FLAG_EMU_EDGE is not set in s->flags, the buffer must contain an
		/// edge of the size returned by avcodec_get_edge_width() on all sides.
		///
		/// avcodec_align_dimensions2() should be used to find the required width and
		/// height, as they normally need to be rounded up to the next multiple of 16.
		///
		/// If frame multithreading is used and thread_safe_callbacks is set,
		/// this callback may be called from a different thread, but not from more
		/// than one at once. Does not need to be reentrant.
		///
		/// @see avcodec_align_dimensions2()
		///
		/// Audio:
		///
		/// Decoders request a buffer of a particular size by setting
		/// AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,
		/// however, utilize only part of the buffer by setting AVFrame.nb_samples
		/// to a smaller value in the output frame.
		///
		/// As a convenience, av_samples_get_buffer_size() and
		/// av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()
		/// functions to find the required data size and to fill data pointers and
		/// linesize. In AVFrame.linesize, only linesize[0] may be set for audio
		/// since all planes must be the same size.
		///
		/// @see av_samples_get_buffer_size(), av_samples_fill_arrays()
		///
		/// - encoding: unused
		/// - decoding: Set by libavcodec, user can override.
		/// </summary>
		internal IntPtr get_buffer2;

		/// <summary>
		/// If non-zero, the decoded audio and video frames returned from
		/// avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
		/// and are valid indefinitely. The caller must free them with
		/// av_frame_unref() when they are not needed anymore.
		/// Otherwise, the decoded frames must not be freed by the caller and are
		/// only valid until the next decode call.
		///
		/// - encoding: unused
		/// - decoding: set by the caller before avcodec_open2().
		/// </summary>
		internal int refcounted_frames;

		//// - encoding parameters /// </summary>
		internal float qcompress;  ///< amount of qscale change between easy & hard scenes (0.0-1.0)
		internal float qblur;      ///< amount of qscale smoothing over time (0.0-1.0)

		/// <summary>
		/// minimum quantizer
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int qmin;

		/// <summary>
		/// maximum quantizer
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int qmax;

		/// <summary>
		/// maximum quantizer difference between frames
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int max_qdiff;

		/// <summary>
		/// ratecontrol qmin qmax limiting method
		/// 0-> clipping, 1-> use a nice continuous function to limit qscale wthin qmin/qmax.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float rc_qsquish;

		internal float rc_qmod_amp;
		internal int rc_qmod_freq;

		/// <summary>
		/// decoder bitstream buffer size
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int rc_buffer_size;

		/// <summary>
		/// ratecontrol override, see RcOverride
		/// - encoding: Allocated/set/freed by user.
		/// - decoding: unused
		/// </summary>
		internal int rc_override_count;
		internal IntPtr rc_override;

		/// <summary>
		/// rate control equation
		/// - encoding: Set by user
		/// - decoding: unused
		/// </summary>
		[MarshalAs(UnmanagedType.LPStr)]
		internal string rc_eq;

		/// <summary>
		/// maximum bitrate
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int rc_max_rate;

		/// <summary>
		/// minimum bitrate
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int rc_min_rate;

		internal float rc_buffer_aggressivity;

		/// <summary>
		/// initial complexity for pass1 ratecontrol
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal float rc_initial_cplx;

		/// <summary>
		/// Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
		/// - encoding: Set by user.
		/// - decoding: unused.
		/// </summary>
		internal float rc_max_available_vbv_use;

		/// <summary>
		/// Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
		/// - encoding: Set by user.
		/// - decoding: unused.
		/// </summary>
		internal float rc_min_vbv_overflow_use;

		/// <summary>
		/// Number of bits which should be loaded into the rc buffer before decoding starts.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		int rc_initial_buffer_occupancy;

		/// <summary>
		/// coder type
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal FF_CODER_TYPE coder_type;

		/// <summary>
		/// context model
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int context_model;

		/// <summary>
		/// minimum Lagrange multipler
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int lmin;

		/// <summary>
		/// maximum Lagrange multipler
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int lmax;

		/// <summary>
		/// frame skip threshold
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int frame_skip_threshold;

		/// <summary>
		/// frame skip factor
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int frame_skip_factor;

		/// <summary>
		/// frame skip exponent
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int frame_skip_exp;

		/// <summary>
		/// frame skip comparison function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int frame_skip_cmp;

		/// <summary>
		/// trellis RD quantization
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int trellis;

		/// <summary>
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int min_prediction_order;

		/// <summary>
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int max_prediction_order;

		/// <summary>
		/// GOP timecode frame start number
		/// - encoding: Set by user, in non drop frame format
		/// - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
		/// </summary>
		internal int64_t timecode_frame_start;

		//// The RTP callback: This function is called    /// </summary>
		//// every time the encoder has a packet to send. /// </summary>
		//// It depends on the encoder if the data starts /// </summary>
		//// with a Start Code (it should). H.263 does.   /// </summary>
		//// mb_nb contains the number of macroblocks     /// </summary>
		//// encoded in the RTP payload.                  /// </summary>
		internal IntPtr rtp_callback;

		internal int rtp_payload_size;   //// The size of the RTP payload: the coder will  /// </summary>
					//// do its best to deliver a chunk with size     /// </summary>
					//// below rtp_payload_size, the chunk will start /// </summary>
					//// with a start code on some codecs like H.263. /// </summary>
					//// This doesn't take account of any particular  /// </summary>
					//// headers inside the transmitted RTP payload.  /// </summary>

		//// statistics, used for 2-pass encoding /// </summary>
		internal int mv_bits;
		internal int header_bits;
		internal int i_tex_bits;
		internal int p_tex_bits;
		internal int i_count;
		internal int p_count;
		internal int skip_count;
		internal int misc_bits;

		/// <summary>
		/// number of bits used for the previously encoded frame
		/// - encoding: Set by libavcodec.
		/// - decoding: unused
		/// </summary>
		internal int frame_bits;

		/// <summary>
		/// pass1 encoding statistics output buffer
		/// - encoding: Set by libavcodec.
		/// - decoding: unused
		/// </summary>
		internal IntPtr stats_out;

		/// <summary>
		/// pass2 encoding statistics input buffer
		/// Concatenated stuff from stats_out of pass1 should be placed here.
		/// - encoding: Allocated/set/freed by user.
		/// - decoding: unused
		/// </summary>
		internal IntPtr stats_in;

		/// <summary>
		/// Work around bugs in encoders which sometimes cannot be detected automatically.
		/// - encoding: Set by user
		/// - decoding: Set by user
		/// </summary>
		internal FF_BUG workaround_bugs;

		/// <summary>
		/// strictly follow the standard (MPEG4, ...).
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// Setting this to STRICT or higher means the encoder and decoder will
		/// generally do stupid things, whereas setting it to unofficial or lower
		/// will mean the encoder might produce output that is not supported by all
		/// spec-compliant decoders. Decoders don't differentiate between normal,
		/// unofficial and experimental (that is, they always try to decode things
		/// when they can) unless they are explicitly asked to behave stupidly
		/// (=strictly conform to the specs)
		/// </summary>
		internal FF_COMPLIANCE strict_std_compliance;

		/// <summary>
		/// error concealment flags
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal FF_EC error_concealment;

		/// <summary>
		/// debug
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal FF_DEBUG debug;

		/// <summary>
		/// debug
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal FF_DEBUG_VIS_MV debug_mv;

		/// <summary>
		/// Error recognition; may misdetect some more or less valid parts as errors.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal AV_EF err_recognition;

		/// <summary>
		/// opaque 64bit number (generally a PTS) that will be reordered and
		/// output in AVFrame.reordered_opaque
		/// @deprecated in favor of pkt_pts
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal int64_t reordered_opaque;

		/// <summary>
		/// Hardware accelerator in use
		/// - encoding: unused.
		/// - decoding: Set by libavcodec
		/// </summary>
		internal IntPtr hwaccel;

		/// <summary>
		/// Hardware accelerator context.
		/// For some hardware accelerators, a global context needs to be
		/// provided by the user. In that case, this holds display-dependent
		/// data FFmpeg cannot instantiate itself. Please refer to the
		/// FFmpeg HW accelerator documentation to know how to fill this
		/// is. e.g. for VA API, this is a struct vaapi_context.
		/// - encoding: unused
		/// - decoding: Set by user
		/// </summary>
		internal IntPtr hwaccel_context;

		/// <summary>
		/// error
		/// - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
		/// - decoding: unused
		/// </summary>
		internal IntPtr error;

		/// <summary>
		/// DCT algorithm, see FF_DCT_/// below
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal FF_DCT dct_algo;

		/// <summary>
		/// IDCT algorithm, see FF_IDCT_/// below.
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal FF_IDCT idct_algo;

		/// <summary>
		/// bits per sample/pixel from the demuxer (needed for huffyuv).
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by user.
		/// </summary>
		internal int bits_per_coded_sample;

		/// <summary>
		/// Bits per sample/pixel of internal libavcodec pixel/sample format.
		/// - encoding: set by user.
		/// - decoding: set by libavcodec.
		/// </summary>
		internal int bits_per_raw_sample;

		#if FF_API_LOWRES
		/// <summary>
		/// low resolution decoding, 1-> 1/2 size, 2->1/4 size
		/// - encoding: unused
		/// - decoding: Set by user.
		/// Code outside libavcodec should access this field using:
		/// av_codec_{get,set}_lowres(avctx)
		/// </summary>
		int lowres;
		#endif

		/// <summary>
		/// the picture in the bitstream
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal IntPtr coded_frame;

		/// <summary>
		/// thread count
		/// is used to decide how many independent tasks should be passed to execute()
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal int thread_count;

		/// <summary>
		/// Which multithreading methods to use.
		/// Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,
		/// so clients which cannot provide future frames should not use it.
		///
		/// - encoding: Set by user, otherwise the default is used.
		/// - decoding: Set by user, otherwise the default is used.
		/// </summary>
		internal FF_THREAD thread_type;

		/// <summary>
		/// Which multithreading methods are in use by the codec.
		/// - encoding: Set by libavcodec.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal int active_thread_type;

		/// <summary>
		/// Set by the client if its custom get_buffer() callback can be called
		/// synchronously from another thread, which allows faster multithreaded decoding.
		/// draw_horiz_band() will be called from other threads regardless of this setting.
		/// Ignored if the default get_buffer() is used.
		/// - encoding: Set by user.
		/// - decoding: Set by user.
		/// </summary>
		internal int thread_safe_callbacks;

		/// <summary>
		/// The codec may call this to execute several independent things.
		/// It will return only after finishing all tasks.
		/// The user may replace this with some multithreaded implementation,
		/// the default implementation will execute the parts serially.
		/// @param count the number of things to execute
		/// - encoding: Set by libavcodec, user can override.
		/// - decoding: Set by libavcodec, user can override.
		/// </summary>
		internal IntPtr execute;

		/// <summary>
		/// The codec may call this to execute several independent things.
		/// It will return only after finishing all tasks.
		/// The user may replace this with some multithreaded implementation,
		/// the default implementation will execute the parts serially.
		/// Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
		/// @param c context passed also to func
		/// @param count the number of things to execute
		/// @param arg2 argument passed unchanged to func
		/// @param ret return values of executed functions, must have space for "count" values. May be NULL.
		/// @param func function that will be called count times, with jobnr from 0 to count-1.
		///             threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
		///             two instances of func executing at the same time will have the same threadnr.
		/// @return always 0 currently, but code should handle a future improvement where when any call to func
		///         returns < 0 no further calls to func may be done and < 0 is returned.
		/// - encoding: Set by libavcodec, user can override.
		/// - decoding: Set by libavcodec, user can override.
		/// </summary>
		internal IntPtr execute2;

		/// <summary>
		/// thread opaque
		/// Can be used by execute() to store some per AVCodecContext stuff.
		/// - encoding: set by execute()
		/// - decoding: set by execute()
		/// </summary>
		internal IntPtr thread_opaque;

		/// <summary>
		/// noise vs. sse weight for the nsse comparsion function
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int nsse_weight;

		/// <summary>
		/// profile
		/// - encoding: Set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal FF_PROFILE profile;

		/// <summary>
		/// level
		/// - encoding: Set by user.
		/// - decoding: Set by libavcodec.
		/// </summary>
		internal int level;
//#define FF_LEVEL_UNKNOWN -99

		/// <summary>
		/// Skip loop filtering for selected frames.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal AVDiscard skip_loop_filter;

		/// <summary>
		/// Skip IDCT/dequantization for selected frames.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal AVDiscard skip_idct;

		/// <summary>
		/// Skip decoding for selected frames.
		/// - encoding: unused
		/// - decoding: Set by user.
		/// </summary>
		internal AVDiscard skip_frame;

		/// <summary>
		/// Header containing style information for text subtitles.
		/// For SUBTITLE_ASS subtitle type, it should contain the whole ASS
		/// [Script Info] and [V4+ Styles] section, plus the [Events] line and
		/// the Format line following. It shouldn't include any Dialogue line.
		/// - encoding: Set/allocated/freed by user (before avcodec_open2())
		/// - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
		/// </summary>
		internal IntPtr subtitle_header;
		internal int subtitle_header_size;

		/// <summary>
		/// Simulates errors in the bitstream to test error concealment.
		/// - encoding: Set by user.
		/// - decoding: unused
		/// </summary>
		internal int error_rate;

		/// <summary>
		/// Current packet as passed into the decoder, to avoid having
		/// to pass the packet into every function. Currently only valid
		/// inside lavc and get/release_buffer callbacks.
		/// - decoding: set by avcodec_decode_///, read by get_buffer() for setting pkt_pts
		/// - encoding: unused
		/// </summary>
		internal IntPtr pkt;

		/// <summary>
		/// VBV delay coded in the last frame (in periods of a 27 MHz clock).
		/// Used for compliant TS muxing.
		/// - encoding: Set by libavcodec.
		/// - decoding: unused.
		/// </summary>
		internal uint64_t vbv_delay;

		/// <summary>
		/// Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
		/// Code outside libavcodec should access this field using:
		/// av_codec_{get,set}_pkt_timebase(avctx)
		/// - encoding unused.
		/// - decoding set by user.
		/// </summary>
		internal AVRational pkt_timebase;

		/// <summary>
		/// AVCodecDescriptor
		/// Code outside libavcodec should access this field using:
		/// av_codec_{get,set}_codec_descriptor(avctx)
		/// - encoding: unused.
		/// - decoding: set by libavcodec.
		/// </summary>
		internal IntPtr codec_descriptor;

		#if !FF_API_LOWRES
		/// <summary>
		/// low resolution decoding, 1-> 1/2 size, 2->1/4 size
		/// - encoding: unused
		/// - decoding: Set by user.
		/// Code outside libavcodec should access this field using:
		/// av_codec_{get,set}_lowres(avctx)
		/// </summary>
		int lowres;
		#endif

		/// <summary>
		/// Current statistics for PTS correction.
		/// - decoding: maintained and used by libavcodec, not intended to be used by user apps
		/// - encoding: unused
		/// </summary>
		internal int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
		internal int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
		internal int64_t pts_correction_last_pts;       /// PTS of the last frame
		internal int64_t pts_correction_last_dts;       /// DTS of the last frame

		/// <summary>
		/// Character encoding of the input subtitles file.
		/// - decoding: set by user
		/// - encoding: unused
		/// </summary>
		internal IntPtr sub_charenc;

		/// <summary>
		/// Subtitles character encoding mode. Formats or codecs might be adjusting
		/// this setting (if they are doing the conversion themselves for instance).
		/// - decoding: set by libavcodec
		/// - encoding: unused
		/// </summary>
		internal FF_SUB_CHARENC_MODE sub_charenc_mode;
		

		/// <summary>
		/// Skip processing alpha if supported by codec.
		/// Note that if the format uses pre-multiplied alpha (common with VP6,
		/// and recommended due to better video quality/compression)
		/// the image will look as if alpha-blended onto a black background.
		/// However for formats that do not use pre-multiplied alpha
		/// there might be serious artefacts (though e.g. libswscale currently
		/// assumes pre-multiplied alpha anyway).
		/// Code outside libavcodec should access this field using AVOptions
		///
		/// - decoding: set by user
		/// - encoding: unused
		/// </summary>
		internal int skip_alpha;
		#endregion
	}
}
